/*
 * @Descripttion:
 * @version:
 * @Author: xiaozilai
 * @Date: 2022-11-10 19:10:37
 * @LastEditors: xiaozilai
 * @LastEditTime: 2022-11-11 15:55:06
 */
/*
 * @lc app=leetcode.cn id=864 lang=cpp
 *
 * [864] 获取所有钥匙的最短路径
 *
 * https://leetcode.cn/problems/shortest-path-to-get-all-keys/description/
 *
 * algorithms
 * Hard (48.25%)
 * Likes:    202
 * Dislikes: 0
 * Total Accepted:    13.2K
 * Total Submissions: 23.1K
 * Testcase Example:  '["@.a..","###.#","b.A.B"]'
 *
 * 给定一个二维网格 grid ，其中：
 *
 *
 * '.' 代表一个空房间
 * '#' 代表一堵
 * '@' 是起点
 * 小写字母代表钥匙
 * 大写字母代表锁
 *
 *
 *
 * 我们从起点开始出发，一次移动是指向四个基本方向之一行走一个单位空间。我们不能在网格外面行走，也无法穿过一堵墙。如果途经一个钥匙，我们就把它捡起来。除非我们手里有对应的钥匙，否则无法通过锁。
 *
 * 假设 k 为 钥匙/锁 的个数，且满足 1 <= k <= 6，字母表中的前 k
 * 个字母在网格中都有自己对应的一个小写和一个大写字母。换言之，每个锁有唯一对应的钥匙，每个钥匙也有唯一对应的锁。另外，代表钥匙和锁的字母互为大小写并按字母顺序排列。
 *
 * 返回获取所有钥匙所需要的移动的最少次数。如果无法获取所有钥匙，返回 -1 。
 *
 *
 *
 * 示例 1：
 *
 *
 *
 *
 * 输入：grid = ["@.a.#","###.#","b.A.B"]
 * 输出：8
 * 解释：目标是获得所有钥匙，而不是打开所有锁。
 *
 *
 * 示例 2：
 *
 *
 *
 *
 * 输入：grid = ["@..aA","..B#.","....b"]
 * 输出：6
 *
 *
 * 示例 3:
 *
 *
 * 输入: grid = ["@Aa"]
 * 输出: -1
 *
 *
 *
 * 提示：
 *
 *
 * m == grid.length
 * n == grid[i].length
 * 1 <= m, n <= 30
 * grid[i][j] 只含有 '.', '#', '@', 'a'-'f' 以及 'A'-'F'
 * 钥匙的数目范围是 [1, 6] 
 * 每个钥匙都对应一个 不同 的字母
 * 每个钥匙正好打开一个对应的锁
 *
 *
 */

// @lc code=start
#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>
using namespace std;
class Solution {
public:
    int shortestPathAllKeys(vector<string> &grid) {
        int m = grid.size(), n = grid[0].size();
        int sx = 0, sy = 0;                  //起点位置
        unordered_map<char, int> key_to_idx; //表示的是当前的钥匙是第几把钥匙 char就是钥匙的字母  int就是第几把钥匙
        //获取起点和钥匙的数量
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == '@') {
                    sx = i;
                    sy = j;
                } else if (islower(grid[i][j])) {
                    if (!key_to_idx.count(grid[i][j])) {
                        int idx = key_to_idx.size();
                        key_to_idx[grid[i][j]] = idx;
                    }
                }
            }
        }

        queue<tuple<int, int, int>> q; // tuple以存储任意数量、任意类型的数据
        //答案数组,dist[i][j][k] (i,j)表示的是位置  k表示当前位置的钥匙状态使用二进制表示 数组中存储的数据就是当前状态的最小步数
        vector<vector<vector<int>>> dist(m, vector<vector<int>>(n, vector<int>(1 << key_to_idx.size(), -1))); //将所有的最小步数首先初始化为-1表示没有被访问过
        q.emplace(sx, sy, 0);                                                                                 //将起点插入
        dist[sx][sy][0] = 0;                                                                                  //设置步数为0
        while (!q.empty()) {
            auto [x, y, mask] = q.front(); //取出头部元素
            q.pop();
            //向四个方向走
            for (int i = 0; i < 4; ++i) {
                int nx = x + dirs[i][0];
                int ny = y + dirs[i][1];
                //如果当前位置没有越界且不是墙
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] != '#') {
                    //如果是空房间或者是起点
                    if (grid[nx][ny] == '.' || grid[nx][ny] == '@') {
                        if (dist[nx][ny][mask] == -1) {                //当前位置如果没有被访问过
                            dist[nx][ny][mask] = dist[x][y][mask] + 1; //当前位置的最小步数就是前一步的最小步数+1
                            q.emplace(nx, ny, mask);                   //并将新的位置放入队列中
                        }
                    }
                    //如果是钥匙
                    else if (islower(grid[nx][ny])) {
                        //获取钥匙的编号（就是二进制中代表当前钥匙的1的位置）
                        int idx = key_to_idx[grid[nx][ny]];
                        //如果当前位置在获取到对应钥匙之后没有被走过
                        if (dist[nx][ny][mask | (1 << idx)] == -1) {
                            //更新最小步数
                            dist[nx][ny][mask | (1 << idx)] = dist[x][y][mask] + 1;
                            //如果发现钥匙已经全部获取完了就直接退出 返回当前位置的最小步数
                            if ((mask | (1 << idx)) == (1 << key_to_idx.size()) - 1) {
                                return dist[nx][ny][mask | (1 << idx)];
                            }
                            //钥匙没有获取完 将当前的钥匙标记为已获取并入队
                            q.emplace(nx, ny, mask | (1 << idx));
                        }
                    }
                    //是锁
                    else {
                        //获取锁对应钥匙的二进制位
                        int idx = key_to_idx[tolower(grid[nx][ny])];
                        //如果当前位置获取到了锁对应的钥匙 且获取到该锁的钥匙之后没有走过就更新
                        if ((mask & (1 << idx)) && dist[nx][ny][mask] == -1) {
                            dist[nx][ny][mask] = dist[x][y][mask] + 1;
                            q.emplace(nx, ny, mask);
                        }
                    }
                }
            }
        }
        return -1;
    }

private:
    //方向向量
    static constexpr int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
};
// @lc code=end
